{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Auxiliary SimulationState components: Diagnostics, Randomness, DynamicInput\n",
        "\n",
        "> **tldr:** This notebook explains how to manage auxiliary simulation state components beyond prognostics. Examples include: diagnostics, randomness, and dynamic inputs (forcings). Each component has a dedicated variable type (`Diagnostic`, `Randomness`, `DynamicInput`) and is managed by a subclasses of base modules (`DiagnosticModule`, `RandomProcessModule`, `DynamicInputModule`). You will learn how to attach Diagnostic modules to inspect intermediate computations (using `with_callback` or explicit definition), how to inject stochasticity using `RandomProcessModule`, and how to provide time-aligned \"forcings\" using `DynamicInputModule`. Finally, it demonstrates how to manage these components when they are nested or shared within a complex model, using the module_utils.retrieve_subclass_modules utility to find all unique module instances for collective operations.\n",
        "\n",
        "In the `Model` API intro tutorial we discussed how model prognostics are stored on the model instance. In this notebook we discuss additional components essential for simulations: 'diagnostics', 'randomness', and 'dynamic inputs' (a.k.a., forcings), as well as the system for managing them.\n",
        "\n",
        "Similar to prognostics, variables for these simulation components are stored on model instances under distinct variable types (`Diagnostic`, `Randomness`, and `DynamicInput`) and are managed by corresponding module subclasses. This design simplifies their initialization and updates.\n",
        "\n",
        "Outline:\n",
        "1. How to attach diagnostic computation to model components\n",
        "2. How to inject stochasticity to model components\n",
        "3. How to provide time-aligned user inputs to model components\n",
        "4. What tools does `Model` provide to manage the associated simulation state and what are the associated contracts\n",
        "\n"
      ],
      "metadata": {
        "id": "tW_MyBy5E2Cs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "! pip install flax==0.12.0\n",
        "! pip install --no-cache-dir git+https://github.com/neuralgcm/coordax.git\n",
        "! pip install --no-cache-dir git+https://github.com/neuralgcm/neuralgcm.git@refs/pull/482/head\n",
        "! pip install jax_datetime jax_solar fiddle"
      ],
      "metadata": {
        "id": "nFvj6ftRV4l_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import dataclasses\n",
        "\n",
        "import coordax as cx\n",
        "from flax import nnx\n",
        "import jax\n",
        "import jax.numpy as jnp\n",
        "import jax_datetime as jdt\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "from neuralgcm.experimental.atmosphere import idealized_states\n",
        "from neuralgcm.experimental.core import coordinates\n",
        "from neuralgcm.experimental.core import dynamic_io\n",
        "from neuralgcm.experimental.core import diagnostics\n",
        "from neuralgcm.experimental.core import nnx_compat\n",
        "from neuralgcm.experimental.core import random_processes\n",
        "from neuralgcm.experimental.core import feature_transforms\n",
        "from neuralgcm.experimental.core import parallelism\n",
        "from neuralgcm.experimental.core import module_utils\n",
        "from neuralgcm.experimental.core import transforms\n",
        "from neuralgcm.experimental.core import spherical_transforms\n",
        "from neuralgcm.experimental.core import typing\n",
        "from neuralgcm.experimental.core import units\n",
        "\n",
        "import logging\n",
        "import warnings\n",
        "warnings.simplefilter('ignore')\n",
        "logging.getLogger('jax._src.lib.xla_bridge').addFilter(lambda _: False)"
      ],
      "metadata": {
        "id": "PNh6XimIK8gw"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## How to attach diagnostic computation\n",
        "\n",
        "**Key concepts:**\n",
        "* `Diagnostic` variables are generally managed by subclasses of `DiagnosticModule`\n",
        "* Diagnostic modules can be added explicitly or using `with_callback` wrapper method"
      ],
      "metadata": {
        "id": "CmDTsAaoK_Pl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "One approach to adding diagnostics is to follow the same pattern used for prognostics, namely store relevant values in `Diagnostic` variable types. Let us first construct a demo module that we will use for diagnostics demo:"
      ],
      "metadata": {
        "id": "kd0RzNurtL6y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# A simple module with an intermediate step we want to inspect\n",
        "@nnx_compat.dataclass\n",
        "class SimpleModule(nnx.Module):\n",
        "  a: float = 2.0\n",
        "  b: float = 3.0\n",
        "\n",
        "  def compute_intermediate(self, x: cx.Field) -> cx.Field:\n",
        "    return x * self.a  # We will use diagnostic tools to inspect these values.\n",
        "\n",
        "  def __call__(self, inputs: dict[str, cx.Field]) -> dict[str, cx.Field]:\n",
        "    x, t = inputs['x'], inputs['t']\n",
        "    intermediate_val = self.compute_intermediate(x)\n",
        "    final_result = intermediate_val * self.b\n",
        "    return {'x': final_result, 't': t + np.timedelta64(1, 'h')}\n"
      ],
      "metadata": {
        "id": "kS3rJgovWTX4"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "metadata": {
        "id": "3an1zgmPW9T7"
      },
      "cell_type": "code",
      "source": [
        "# Instantiating and running demo module.\n",
        "simple_module = SimpleModule()\n",
        "coords = cx.LabeledAxis('x', [0, 1, 2])\n",
        "x_data = cx.wrap(jnp.array([10., 20., 30.]), coords)\n",
        "inputs = {'x': x_data, 't': jdt.to_datetime('2000-01-01')}\n",
        "simple_outputs = simple_module(inputs)\n",
        "simple_outputs"
      ],
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'x': <Field dims=('x',) shape=(3,) axes={'x': LabeledAxis} >,\n",
              " 't': jax_datetime.Datetime(delta=jax_datetime.Timedelta(days=10957, seconds=3600))}"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "execution_count": 6
    },
    {
      "cell_type": "markdown",
      "source": [
        "When interacting with the module explicitly, it is easy enough to expose parts of the computation and inspect intermediate values. This becomes cumbersome when the component is nested deeply inside other modules for several reasons:\n",
        "* Generating inputs to the module in question might require the user to reconstruct a complex computation\n",
        "* Diagnostics that span multiple calls require even more care as modules are stateful and multiple calls might lead to a different result\n",
        "\n",
        "Diagnostics provide a way to collect and expose information about intermediate computation without the need to perform such reconstructions.\n",
        "\n",
        "The core idea is to modify the module of interest with a wrapper that holds:\n",
        "1. The original module that will be used to perform the same computation\n",
        "2. A `DiagnosticModule` that collects diagnostics into `Diagnostic` state\n",
        "\n",
        "`DiagnosticModule` classes collect and manage the diagnostic state. The base class API is:\n",
        "```python\n",
        "class DiagnosticModule(nnx.Module):\n",
        "\n",
        "  @abc.abstractmethod\n",
        "  def __call__(self, module_outputs, *in_args, **in_kwargs) -> None:\n",
        "    \"\"\"Updates diagnostic state using module_outputs and input arguments.\"\"\"\n",
        "\n",
        "  @abc.abstractmethod\n",
        "  def diagnostic_values(self) -> typing.Pytree:\n",
        "    \"\"\"Returns diagnostic values computed from the internal module state.\"\"\"\n",
        "\n",
        "  @abc.abstractmethod\n",
        "  def reset_diagnostic_state(self):\n",
        "    \"\"\"Resets the internal diagnostic state.\"\"\"\n",
        "```\n",
        "\n",
        "Inputs to the core `__call__` method are:\n",
        "1. Outputs of a module method it is configured to inspect;\n",
        "2. Inputs to the module arguments\n",
        "\n",
        "The `__call__` method uses these inputs to update relevant `Diagnostic` variables in place.\n",
        "\n",
        "The other two methods compute final diagnostic values from the internal representation and reset the diagnostic state respectively."
      ],
      "metadata": {
        "id": "LZRP6l9TYGSB"
      }
    },
    {
      "metadata": {
        "id": "KeO1pm363FdK"
      },
      "cell_type": "markdown",
      "source": [
        "NeuralGCM provides several basic diagnostic modules:\n",
        "* InstantDiagnostic\n",
        "* CumulativeDiagnostic\n",
        "\n",
        "These modules manage an instantenious and cumulative diagnostic values respectively. \\\n",
        "They are parameterized by an `extract_fn(module_outputs, *in_args, **in_kwargs)` callable that computes a single set of values.\n",
        "\n",
        "Let's see this in practice by inspecting the intermediate value (outputs of `compute_intermediate`) in the SimpleModule. Here we will use `module_utils.with_callaback` to inject the diagnostic computation. This will be done in four steps:\n",
        "1. Define coordinates for the snapshot of diagnostic values\n",
        "2. Define a function that will accept output and all args of `compute_intermediate` method and compute diagnostic values\n",
        "3. Instantiate diagnostic module that will hold `Diagnostic` variables using (1, 2)\n",
        "4. Use `with_callback` to attach diagnostic module to `simple_model.compute_intermediate` method"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Coordinates for the expected diagnostic value.\n",
        "diagnostic_coords = {'intermediate': coords}\n",
        "\n",
        "# Function that extracts just outputs from `compute_intermediate`:\n",
        "extract_fn = lambda outputs, *args, **kwargs: {'intermediate': outputs}\n",
        "\n",
        "# Diagnostic instance:\n",
        "diagnostic = diagnostics.InstantDiagnostic(\n",
        "    extract=extract_fn,\n",
        "    extract_coords=diagnostic_coords,\n",
        ")\n",
        "\n",
        "# Attaching diagnostic to `compute_intermediate` method on `SimpleModule` module\n",
        "wrapped_module = module_utils.with_callback(\n",
        "    simple_module,  # Module with the method we want to compute diagnostic from.\n",
        "    diagnostic,  # DiagnosticModule to attach.\n",
        "    'compute_intermediate' # The name of the method to inspect with diagnostic.\n",
        ")\n",
        "\n",
        "also_simple_output = wrapped_module(inputs)\n",
        "diagnostic_values = diagnostic.diagnostic_values()\n",
        "\n",
        "print(f\"Input Data: {inputs['x'].data}\")\n",
        "print(f\"Original Output: {simple_outputs['x'].data}\")\n",
        "print(f\"Wrapped Output: {also_simple_output['x'].data}\")\n",
        "print(f\"Diagnosed value: {diagnostic_values['intermediate'].data}\")"
      ],
      "metadata": {
        "id": "PoBxBJgfX-kG"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input Data: [10. 20. 30.]\n",
            "Original Output: [ 60. 120. 180.]\n",
            "Wrapped Output: [ 60. 120. 180.]\n",
            "Diagnosed value: [20. 40. 60.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "By inspecting the wrapped module we can find that a reference to `diagnostic` is now stored on the wrapped module."
      ],
      "metadata": {
        "id": "9rhCWxRXcDRA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nnx.display(wrapped_module)"
      ],
      "metadata": {
        "id": "GiDyQBuBcQht",
        "colab": {
          "height": 457
        },
        "outputId": "7059220c-bfa8-41e9-ee34-8d0eb31d0cd0"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<script> (()=>{ if (customElements.get('treescope-container') === undefined) { class TreescopeContainer extends HTMLElement { constructor() { super(); this.attachShadow({mode: \"open\"}); this.defns = {}; this.state = {}; } } customElements.define(\"treescope-container\", TreescopeContainer); } if (customElements.get('treescope-run-here') === undefined) { class RunHere extends HTMLElement { constructor() { super() } connectedCallback() { const run = child => { const fn = new Function(child.textContent); child.textContent = \"\"; fn.call(this); this.remove(); }; const child = this.querySelector(\"script\"); if (child) { run(child); } else { new MutationObserver(()=>{ run(this.querySelector(\"script\")); }).observe(this, {childList: true}); } } } customElements.define(\"treescope-run-here\", RunHere); } })(); </script> <treescope-container class=\"treescope_out_04c5677be86d426786858f5e023f0073\" style=\"display:block\"></treescope-container> <treescope-run-here><script type=\"application/octet-stream\"> const root = ( Array.from(document.getElementsByClassName( \"treescope_out_04c5677be86d426786858f5e023f0073\")) .filter((elt) => !elt.dataset.setup) )[0]; root.dataset.setup = 1; const msg = document.createElement(\"span\"); msg.style = \"color: #cccccc; font-family: monospace;\"; msg.textContent = \"(Loading...)\"; root.state.loadingMsg = msg; root.shadowRoot.appendChild(msg); root.state.chain = new Promise((resolve, reject) => { const observer = new IntersectionObserver((entries) => { for (const entry of entries) { if (entry.isIntersecting) { resolve(); observer.disconnect(); return; } } }, {rootMargin: \"1000px\"}); window.setTimeout(() => { observer.observe(root); }, 0); }); root.state.deferring = false; const _insertNode = (node) => { for (let oldScript of node.querySelectorAll(\"script\")) { let newScript = document.createElement(\"script\"); newScript.type = oldScript.type; newScript.textContent = oldScript.textContent; oldScript.parentNode.replaceChild(newScript, oldScript); } if (root.state.loadingMsg) { root.state.loadingMsg.remove(); root.state.loadingMsg = null; } root.shadowRoot.appendChild(node); }; root.defns.insertContent = ((contentNode, compressed) => { if (compressed) { root.state.deferring = true; } if (root.state.deferring) { root.state.chain = (async () => { await root.state.chain; if (compressed) { const encoded = contentNode.textContent; const blob = new Blob([ Uint8Array.from(atob(encoded), (m) => m.codePointAt(0)) ]); const reader = blob.stream().pipeThrough( new DecompressionStream(\"deflate\") ).pipeThrough( new TextDecoderStream(\"utf-8\") ).getReader(); const parts = []; while (true) { const step = await reader.read(); if (step.done) { break; } parts.push(step.value); } const tpl = document.createElement('template'); tpl.innerHTML = parts.join(\"\"); _insertNode(tpl.content); } else { _insertNode(contentNode.content); } })(); } else { _insertNode(contentNode.content); } }); </script></treescope-run-here><div style=\"display:none\"> <script type=\"application/octet-stream\" >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</script> <treescope-run-here><script type=\"application/octet-stream\"> const root = ( Array.from(document.getElementsByClassName( \"treescope_out_04c5677be86d426786858f5e023f0073\")) .filter((elt) => !elt.dataset['step0']) )[0]; root.dataset['step0'] = 1; root.defns.insertContent( this.parentNode.querySelector('script[type=\"application/octet-stream\"]'), true ); this.parentNode.remove(); </script></treescope-run-here> </div>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<div style=\"display:none\"> <script type=\"application/octet-stream\" >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</script> <treescope-run-here><script type=\"application/octet-stream\"> const root = ( Array.from(document.getElementsByClassName( \"treescope_out_04c5677be86d426786858f5e023f0073\")) .filter((elt) => !elt.dataset['step1']) )[0]; root.dataset['step1'] = 1; root.defns.insertContent( this.parentNode.querySelector('script[type=\"application/octet-stream\"]'), true ); this.parentNode.remove(); </script></treescope-run-here> </div>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "`with_callback` approach provides a fast path for injecting diagnostics, which is ideal for inspection and debugging.\n",
        "\n",
        "If a diagnostic is known to be required upfront, it can be included as an explicit attribute in the module's definition:"
      ],
      "metadata": {
        "id": "WvPjKen_cZL-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Module with explicit diagnostic included.\n",
        "\n",
        "@nnx_compat.dataclass\n",
        "class SimpleModuleWithDiagnostic(SimpleModule):\n",
        "  diagnostic: diagnostics.InstantDiagnostic = dataclasses.field(kw_only=True)\n",
        "\n",
        "  def __call__(self, inputs):\n",
        "    x, t = inputs['x'], inputs['t']\n",
        "    intermediate_val = self.compute_intermediate(x)\n",
        "    self.diagnostic(intermediate_val, x)\n",
        "    final_result = intermediate_val * self.b\n",
        "    return {'x': final_result, 't': t + np.timedelta64(1, 'h')}"
      ],
      "metadata": {
        "id": "JLTeo5SXc--G"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "diagnostic = diagnostics.InstantDiagnostic(\n",
        "    extract=extract_fn,\n",
        "    extract_coords=diagnostic_coords,\n",
        ")\n",
        "simple_with_diagnostic = SimpleModuleWithDiagnostic(diagnostic=diagnostic)\n",
        "_ = simple_with_diagnostic(inputs)"
      ],
      "metadata": {
        "id": "ZwRv4YbIdlhx"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "diagnostic_values = diagnostic.diagnostic_values()\n",
        "print(f\"Diagnosed value: {diagnostic_values['intermediate'].data}\")"
      ],
      "metadata": {
        "id": "vlfR2FJ2dySa",
        "colab": {
          "height": 241
        },
        "outputId": "077a64b5-77cd-4142-abea-1f3af4f2a01d"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Diagnosed value: [20. 40. 60.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## How to inject stochasticity to model components\n",
        "\n",
        "**Key concepts:**\n",
        "* `RandomProcessModule` subclasses provides an interface for managing `Randomness` state variables.\n",
        "* Random processes feature api similar to an independent model implementing `unconditional_sample`, `advance` and `state_values`"
      ],
      "metadata": {
        "id": "gPxr3Smpd5Me"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "One powerful approach to modeling unresolved dynamics is to introduce stochasticity to the computation, driven by a prescribed random process. The NeuralGCM codebase provides the RandomProcessModule API to help define these random processes and maintain their associated state. The underlying state is wrapped in `Randomness` variable type. For examples let's have a look at two different random processes:\n",
        "1. NormalUncorrelated - uncorrelated samples from normal distribution\n",
        "2. GaussianRandomField - spatially and temporally correlated gaussian process"
      ],
      "metadata": {
        "id": "BAL0Wr6khGk3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sim_units = units.get_si_units()\n",
        "grid = coordinates.LonLatGrid.T42()\n",
        "ylm_grid = coordinates.SphericalHarmonicGrid.T42()\n",
        "ylm_map = spherical_transforms.FixedYlmMapping(\n",
        "    grid,\n",
        "    ylm_grid,\n",
        "    partition_schema_key=None,\n",
        "    mesh=parallelism.Mesh(),\n",
        "    radius=sim_units.radius,\n",
        ")\n",
        "uncorrelated = random_processes.NormalUncorrelated(\n",
        "    grid, mean=0.0, std=1.0, rngs=nnx.Rngs(0)\n",
        ")\n",
        "gaussian_random_process = random_processes.GaussianRandomField(\n",
        "    ylm_map, 3600, sim_units, '10 hours', '500 km', 1.0, rngs=nnx.Rngs(1)\n",
        ")"
      ],
      "metadata": {
        "id": "5FocyJquhE9a"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rng = cx.wrap(jax.random.key(0))\n",
        "uncorrelated.unconditional_sample(rng)\n",
        "gaussian_random_process.unconditional_sample(rng)"
      ],
      "metadata": {
        "id": "Gk6d3Pcyh9xG"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "uncorrelated_randomness = uncorrelated.state_values()\n",
        "gaussian_process_randomness = gaussian_random_process.state_values()\n",
        "fig, axarray = plt.subplots(2, 2, figsize=(14, 8))\n",
        "uncorrelated_randomness.to_xarray().plot(x='longitude', y='latitude', ax=axarray[0, 0])\n",
        "gaussian_process_randomness.to_xarray().plot(x='longitude', y='latitude', ax=axarray[0, 1])\n",
        "\n",
        "# call advance\n",
        "uncorrelated.advance()\n",
        "gaussian_random_process.advance()\n",
        "uncorrelated_randomness = uncorrelated.state_values()\n",
        "gaussian_process_randomness = gaussian_random_process.state_values()\n",
        "uncorrelated_randomness.to_xarray().plot(x='longitude', y='latitude', ax=axarray[1, 0])\n",
        "gaussian_process_randomness.to_xarray().plot(x='longitude', y='latitude', ax=axarray[1, 1])"
      ],
      "metadata": {
        "id": "XxJf1p8FiLot",
        "colab": {
          "height": 513
        },
        "outputId": "1c721b84-9659-46ec-f5d4-54642bd7ffef"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.QuadMesh at 0x33db5824b530>"
            ]
          },
          "metadata": {},
          "execution_count": 26
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1008x576 with 8 Axes>"
            ]
          },
          "metadata": {
            "image/png": {
              "height": 479,
              "width": 815
            },
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As mentioned before, the state of the random process is stored on the module. These modules can be shared by multiple model components to draw values from.\n",
        "\n",
        "Example usage of such modules include:\n",
        "* Stochastic perturbation of parameterization tendencies\n",
        "* Random features used by neural networks"
      ],
      "metadata": {
        "id": "T-46R117z9xi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## How to ingest time-aligned user inputs into model components\n",
        "\n",
        "**Key concepts:**\n",
        "* `DynamicInputModule` subclasses provide mechanisms for storing and accessing time-aware user data.\n",
        "* Values in Dynamic inputs are accessed by the `time` argument"
      ],
      "metadata": {
        "id": "xbMX-eF-01JN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Simulations are also frequently driven by external user inputs, sometimes known as \"forcings,\" that models conditions on.\n",
        "\n",
        "In NeuralGCM codebase such functionality is provided by `DynamicInputModule` subclasses. They take responsibility for storing user inputs wrapped in a `DynamicInput` variable type and provide two methods:\n",
        "1. `update_dynamic_inputs(dynamic_inputs: dict[str, Fields]) -> None:` - that updates values stored by the module\n",
        "2. `__call__(time: jdt.Datetime) -> Fields:` that retrieves values associated with `time` argument\n",
        "\n",
        "Different modules may use different structure of data provided by the user and implement their own time alignment mechanics. The simplest version is the `DynamicInputSlice` module, which stores user-provided, time-indexed values and retrieves the closest match for a requested time.\n",
        "\n",
        "Let's take see this module in action"
      ],
      "metadata": {
        "id": "9IT3T9xd2We5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "grid = coordinates.LonLatGrid.T42()\n",
        "dynamic_input = dynamic_io.DynamicInputSlice(\n",
        "    keys_to_coords={'a': grid},  # specifies data coords (modulo the time axis).\n",
        "    observation_key='abc',  # specifies data_source key associated with data.\n",
        ")\n",
        "\n",
        "# Defining user provided data for field 'a'.\n",
        "data_for_times = np.arange(2)[:, None, None]\n",
        "data = {'abc': {'a': data_for_times * np.ones(grid.shape)}}\n",
        "t_delta_between_data = np.timedelta64(6, 'h')\n",
        "timedelta = coordinates.TimeDelta(np.arange(2) * t_delta_between_data)\n",
        "dt_and_grid = cx.compose_coordinates(timedelta, grid)\n",
        "in_data = jax.tree.map(lambda x: cx.wrap(x, dt_and_grid), data)\n",
        "\n",
        "# All DynamicInputSlice configuration require `time` key to associated `time`\n",
        "# values with `timedelta` axis on the data.\n",
        "t0 = jdt.to_datetime('2000-01-01')\n",
        "time = t0 + timedelta.fields['timedelta']\n",
        "in_data['abc']['time'] = time\n",
        "\n",
        "# updating values stored on the module.\n",
        "dynamic_input.update_dynamic_inputs(in_data)\n",
        "\n",
        "# probing values returned for different time arguments.\n",
        "print(dynamic_input(t0 + np.timedelta64(1, 'h'))['a'].data.max())  # t0 closer.\n",
        "print(dynamic_input(t0 + np.timedelta64(3, 'h'))['a'].data.max())  # t0 closer.\n",
        "print(dynamic_input(t0 + np.timedelta64(6, 'h'))['a'].data.max())  # t0 + 6.\n",
        "print(dynamic_input(t0 + np.timedelta64(30, 'h'))['a'].data.max())  # t0 + 6."
      ],
      "metadata": {
        "id": "3uOxTBOn3_Xv",
        "outputId": "0a7a4c89-71a1-4a26-8b81-400556495568"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0\n",
            "0.0\n",
            "1.0\n",
            "1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's update the `time` associated with the underlying dynamic data by shifting it one day forward. This will affect the outputs for the same time queries:"
      ],
      "metadata": {
        "id": "nVO92u7GN8j6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "in_data['abc']['time'] = time + cx.wrap(jdt.Timedelta(days=1))\n",
        "dynamic_input.update_dynamic_inputs(in_data)\n",
        "# no longer returns 1 since t0 + 24 is not past t0 + 24 + 6;\n",
        "print(dynamic_input(t0 + np.timedelta64(24, 'h'))['a'].data.max())\n",
        "print(dynamic_input(t0 + np.timedelta64(30, 'h'))['a'].data.max())"
      ],
      "metadata": {
        "id": "vVRyi9-IN8VK",
        "outputId": "15d80a97-7fce-4b65-c833-f58331bbed98"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.0\n",
            "1.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can see that the state associated with inputs is stored on the module"
      ],
      "metadata": {
        "id": "nnTE3F7U7NXJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nnx.state(dynamic_input, typing.DynamicInput)"
      ],
      "metadata": {
        "id": "RzkFxHfK8eqz",
        "outputId": "e2e14c27-54ca-44fa-f657-019a33cc8906"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "State({\n",
              "  'data': DynamicInput( # 16,384 (131.1 KB)\n",
              "    value={'a': <Field (\n",
              "      dims=('timedelta', 'longitude', 'latitude'),\n",
              "      shape=(2, 128, 64),\n",
              "      axes={\n",
              "        'timedelta': <TimeDelta[0:00:00, 6:00:00]>,\n",
              "        'longitude': SelectedAxis(coordinate=LonLatGrid(<5 fields...>), axis=0),\n",
              "        'latitude': SelectedAxis(coordinate=LonLatGrid(<5 fields...>), axis=1),\n",
              "      },\n",
              "    )}\n",
              "  ),\n",
              "  'time': DynamicInput( # 4 (16 B)\n",
              "    value=<Field dims=('timedelta',) shape=(2,) axes={'timedelta': TimeDelta} >\n",
              "  )\n",
              "})"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Mechanisms for managing multiple components with additional simulation state\n",
        "\n",
        "**Key concepts:**\n",
        "* Model components can contain many, potentially shared, modules that keep track of additional simulation state variables\n",
        "* Collective calls to all subcomponents are facilitated by `module_utils.retrieve_subclass_modules` helper"
      ],
      "metadata": {
        "id": "JToez3PN7M7t"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "As `Model` instances grow, managing the initialization and manipulation of many nested, stateful sub-components becomes cumbersome.\n",
        "\n",
        "Furthermore, multiple components may need to be shared across different parts of the model.\n",
        "\n",
        "Let's build an example where two sub-components might use the same set of dynamic inputs."
      ],
      "metadata": {
        "id": "iRXF0XYdBdOq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "@nnx_compat.dataclass\n",
        "class RadiationParameterization(nnx.Module):\n",
        "  co2_features: feature_transforms.DynamicInputFeatures\n",
        "\n",
        "  def __call__(self, inputs):\n",
        "    co2_feature_values = self.co2_features(inputs)\n",
        "    return co2_feature_values  # would actually return radiation values.\n",
        "\n",
        "\n",
        "@nnx_compat.dataclass\n",
        "class CarbonCycleParameterization(nnx.Module):\n",
        "  co2_features: feature_transforms.DynamicInputFeatures\n",
        "\n",
        "  def __call__(self, other_inputs):\n",
        "    co2_feature_values = self.co2_features(other_inputs)\n",
        "    return co2_feature_values  # would actually return carbon cycle updates.\n",
        "\n",
        "\n",
        "@nnx_compat.dataclass\n",
        "class CombinedParameterization(nnx.Module):\n",
        "  radiation: RadiationParameterization\n",
        "  carbon_cycle: CarbonCycleParameterization\n",
        "\n",
        "  def __call__(self, inputs):\n",
        "    ..."
      ],
      "metadata": {
        "id": "hTMyzfUaWeNB"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If we instantiate a single dynamic input feature module and share it across the two sub-parameterizations, then combined parameterization will store only 1 copy of CO2 forcing."
      ],
      "metadata": {
        "id": "_gpr_PR6b8Uv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t0 = jdt.to_datetime('2000-01-01')\n",
        "timedelta = coordinates.TimeDelta(np.arange(12) * np.timedelta64(30, 'D'))\n",
        "time = t0 + timedelta.fields['timedelta']\n",
        "values = cx.wrap(\n",
        "    370*np.exp(0.0063 * timedelta.deltas / np.timedelta64(365, 'D')), timedelta\n",
        ")\n",
        "co2_forcing_values = {'global': {'co2': values, 'time': time}}\n",
        "\n",
        "co2_forcing = dynamic_io.DynamicInputSlice({'co2': cx.Scalar()}, observation_key='global')\n",
        "co2_features = feature_transforms.DynamicInputFeatures(['co2'], co2_forcing)\n",
        "radiation = RadiationParameterization(co2_features)\n",
        "carbon_cycle = CarbonCycleParameterization(co2_features)  # same co2_features.\n",
        "combined = CombinedParameterization(radiation, carbon_cycle)"
      ],
      "metadata": {
        "id": "PPMtAGIGb7W3"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "nnx.state(combined, typing.DynamicInput)"
      ],
      "metadata": {
        "id": "pDbQ_2o-cmsg",
        "outputId": "faa06000-03de-4ce3-f5a3-5d8ea527f930"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "State({\n",
              "  'carbon_cycle': {\n",
              "    'co2_features': {\n",
              "      'dynamic_input_module': {\n",
              "        'data': DynamicInput( # 1 (4 B)\n",
              "          value={'co2': <Field dims=('timedelta',) shape=(1,) axes={'timedelta': TimeDelta} >}\n",
              "        ),\n",
              "        'time': DynamicInput( # 2 (16 B)\n",
              "          value=<Field dims=('timedelta',) shape=(1,) axes={'timedelta': TimeDelta} >\n",
              "        )\n",
              "      }\n",
              "    }\n",
              "  }\n",
              "})"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To update the values we have several options:\n",
        "1. update the underlying module directly\n",
        "2. update using any of the references"
      ],
      "metadata": {
        "id": "joBfhk3ecp_B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "co2_forcing.update_dynamic_inputs(co2_forcing_values)\n",
        "inputs_a = {'time': cx.wrap(jdt.to_datetime('2000-01-01'))}\n",
        "inputs_b = {'time': cx.wrap(jdt.to_datetime('2000-04-01'))}\n",
        "inputs_c = {'time': cx.wrap(jdt.to_datetime('2000-09-01'))}\n",
        "print(combined.radiation(inputs_a)['co2'].data)\n",
        "print(combined.radiation(inputs_b)['co2'].data)\n",
        "print(combined.radiation(inputs_c)['co2'].data)\n",
        "print(combined.carbon_cycle(inputs_c)['co2'].data)"
      ],
      "metadata": {
        "id": "roUcs-I1aRj5",
        "outputId": "e8b8d728-cb8f-42c2-b6c9-e6a32d8e35f6"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "370.0\n",
            "370.5752\n",
            "371.5359\n",
            "371.5359\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We could have also called\n",
        "```\n",
        "carbon_cycle.co2_features.dynamic_input_module.update_dynamic_inputs(co2_forcing_values)\n",
        "```\n",
        "to achieve the same effect, but that requires remembering the model structure.\n",
        "This approach also runs into a danger of calling the same module multiple times.\n",
        "\n",
        "To update all unique components of a specific type (e.g., DynamicInputModule) exactly once, use the `module_utils.retrieve_subclass_modules` helper function:"
      ],
      "metadata": {
        "id": "rqrehzHMc4Dk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(module_utils.retrieve_subclass_modules(\n",
        "    combined, dynamic_io.DynamicInputModule\n",
        "))"
      ],
      "metadata": {
        "id": "jSrFl20udQ4y",
        "outputId": "1d61a38b-8c70-456b-e479-4ec3db8dc730"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[DynamicInputSlice( # DynamicInput: 36 (192 B)\n",
            "  keys_to_coords={'co2': Scalar()},\n",
            "  observation_key='global',\n",
            "  time_axis=0,\n",
            "  time=DynamicInput( # 24 (96 B)\n",
            "    value=<Field dims=('timedelta',) shape=(12,) axes={'timedelta': TimeDelta} >\n",
            "  ),\n",
            "  data=DynamicInput( # 12 (96 B)\n",
            "    value={'co2': <Field dims=('timedelta',) shape=(12,) axes={'timedelta': TimeDelta} >}\n",
            "  )\n",
            ")]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This identifies that the CombinedParameterization contains only 1 unique instance. Here's what happens if each parameterization carries a distinct module:"
      ],
      "metadata": {
        "id": "EDCVsHIzdX0L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "co2_forcing_radiation = dynamic_io.DynamicInputSlice({'co2': cx.Scalar()}, observation_key='atm')\n",
        "co2_features_radiation = feature_transforms.DynamicInputFeatures(['co2'], co2_forcing_radiation)\n",
        "\n",
        "co2_forcing_carbon = dynamic_io.DynamicInputSlice({'co2': cx.Scalar()}, observation_key='soil')\n",
        "co2_features_carbon = feature_transforms.DynamicInputFeatures(['co2'], co2_forcing_carbon)\n",
        "\n",
        "radiation = RadiationParameterization(co2_features_radiation)\n",
        "carbon_cycle = CarbonCycleParameterization(co2_features_carbon)\n",
        "combined_distinct = CombinedParameterization(radiation, carbon_cycle)\n",
        "print(module_utils.retrieve_subclass_modules(\n",
        "    combined_distinct, dynamic_io.DynamicInputModule\n",
        "))"
      ],
      "metadata": {
        "id": "q_7mDVTqdwPs",
        "outputId": "74a8d4b8-4fc9-4c8a-a63a-2ca3368aea15"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[DynamicInputSlice( # DynamicInput: 3 (20 B)\n",
            "  keys_to_coords={'co2': Scalar()},\n",
            "  observation_key='soil',\n",
            "  time_axis=0,\n",
            "  time=DynamicInput( # 2 (16 B)\n",
            "    value=<Field dims=('timedelta',) shape=(1,) axes={'timedelta': TimeDelta} >\n",
            "  ),\n",
            "  data=DynamicInput( # 1 (4 B)\n",
            "    value={'co2': <Field dims=('timedelta',) shape=(1,) axes={'timedelta': TimeDelta} >}\n",
            "  )\n",
            "), DynamicInputSlice( # DynamicInput: 3 (20 B)\n",
            "  keys_to_coords={'co2': Scalar()},\n",
            "  observation_key='atm',\n",
            "  time_axis=0,\n",
            "  time=DynamicInput( # 2 (16 B)\n",
            "    value=<Field dims=('timedelta',) shape=(1,) axes={'timedelta': TimeDelta} >\n",
            "  ),\n",
            "  data=DynamicInput( # 1 (4 B)\n",
            "    value={'co2': <Field dims=('timedelta',) shape=(1,) axes={'timedelta': TimeDelta} >}\n",
            "  )\n",
            ")]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This utility is used by several `Model` helper functions to orchestrate calls to all subcomponents of a specific type.\n",
        "* `update_dynamic_inputs` - calls `update_dynamic_input` on all `DynamicInputModele` components\n",
        "* `initialize_random_processes` - calls `unconditional_sample` on all `RandomProcessModule` components\n",
        "* `reset_diagnostic_state` - calls `reset_diagnostic_state` on all `DiagnosticModule` components\n",
        "* `diagnostic_values` - calls `diagnostic_values` on all `DiagnosticModule` components"
      ],
      "metadata": {
        "id": "TWkjf2_CdGoR"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "tqLUd375OkXZ"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
